/*
 * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.context.annotation;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.core.type.filter.AspectJTypeFilter;
import org.springframework.core.type.filter.AssignableTypeFilter;
import org.springframework.core.type.filter.RegexPatternTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

/**
 * Parser for the @{@link ComponentScan} annotation.
 *
 * @author Chris Beams
 * @author Juergen Hoeller
 * @author Sam Brannen
 * @since 3.1
 * @see ClassPathBeanDefinitionScanner#scan(String...)
 * @see ComponentScanBeanDefinitionParser
 */
class ComponentScanAnnotationParser {

	private final Environment environment;

	private final ResourceLoader resourceLoader;

	private final BeanNameGenerator beanNameGenerator;

	private final BeanDefinitionRegistry registry;


	public ComponentScanAnnotationParser(Environment environment, ResourceLoader resourceLoader,
			BeanNameGenerator beanNameGenerator, BeanDefinitionRegistry registry) {

		this.environment = environment;
		this.resourceLoader = resourceLoader;
		this.beanNameGenerator = beanNameGenerator;
		this.registry = registry;
	}


	/**
	 * 解析给定的组件扫描注解属性，并返回一组Bean定义持有者。
	 *
	 * @param componentScan 组件扫描的注解属性，包含扫描的配置如基包、过滤器等。
	 * @param declaringClass 声明该组件扫描注解的类名称。
	 * @return 一组Bean定义持有者，代表着被扫描到的组件。
	 */
	public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
	    // 初始化类路径Bean定义扫描器
	    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
	            componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

	    // 设置Bean名称生成器
	    Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
	    boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
	    scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
	            BeanUtils.instantiateClass(generatorClass));

	    // 设置代理模式
	    ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
	    if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
	        scanner.setScopedProxyMode(scopedProxyMode);
	    }
	    else {
	        // 如果代理模式为默认，则设置作用域元数据解析器
	        Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
	        scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
	    }

	    // 设置资源模式
	    scanner.setResourcePattern(componentScan.getString("resourcePattern"));

	    // 添加包含过滤器
	    for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
	        for (TypeFilter typeFilter : typeFiltersFor(filter)) {
	            scanner.addIncludeFilter(typeFilter);
	        }
	    }
	    // 添加排除过滤器
	    for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
	        for (TypeFilter typeFilter : typeFiltersFor(filter)) {
	            scanner.addExcludeFilter(typeFilter);
	        }
	    }

	    // 设置延迟初始化
	    boolean lazyInit = componentScan.getBoolean("lazyInit");
	    if (lazyInit) {
	        scanner.getBeanDefinitionDefaults().setLazyInit(true);
	    }

	    // 确定要扫描的基包
	    Set<String> basePackages = new LinkedHashSet<>();
	    String[] basePackagesArray = componentScan.getStringArray("basePackages");
	    for (String pkg : basePackagesArray) {
	        String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
	                ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
	        Collections.addAll(basePackages, tokenized);
	    }
	    for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
	        basePackages.add(ClassUtils.getPackageName(clazz));
	    }
	    if (basePackages.isEmpty()) {
	        basePackages.add(ClassUtils.getPackageName(declaringClass));
	    }

	    // 排除当前声明类的扫描
	    scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
	        @Override
	        protected boolean matchClassName(String className) {
	            return declaringClass.equals(className);
	        }
	    });

	    // 执行扫描并返回结果
	    return scanner.doScan(StringUtils.toStringArray(basePackages));
	}

	private List<TypeFilter> typeFiltersFor(AnnotationAttributes filterAttributes) {
		List<TypeFilter> typeFilters = new ArrayList<>();
		FilterType filterType = filterAttributes.getEnum("type");

		for (Class<?> filterClass : filterAttributes.getClassArray("classes")) {
			switch (filterType) {
				case ANNOTATION:
					Assert.isAssignable(Annotation.class, filterClass,
							"@ComponentScan ANNOTATION type filter requires an annotation type");
					@SuppressWarnings("unchecked")
					Class<Annotation> annotationType = (Class<Annotation>) filterClass;
					typeFilters.add(new AnnotationTypeFilter(annotationType));
					break;
				case ASSIGNABLE_TYPE:
					typeFilters.add(new AssignableTypeFilter(filterClass));
					break;
				case CUSTOM:
					Assert.isAssignable(TypeFilter.class, filterClass,
							"@ComponentScan CUSTOM type filter requires a TypeFilter implementation");

					TypeFilter filter = ParserStrategyUtils.instantiateClass(filterClass, TypeFilter.class,
							this.environment, this.resourceLoader, this.registry);
					typeFilters.add(filter);
					break;
				default:
					throw new IllegalArgumentException("Filter type not supported with Class value: " + filterType);
			}
		}

		for (String expression : filterAttributes.getStringArray("pattern")) {
			switch (filterType) {
				case ASPECTJ:
					typeFilters.add(new AspectJTypeFilter(expression, this.resourceLoader.getClassLoader()));
					break;
				case REGEX:
					typeFilters.add(new RegexPatternTypeFilter(Pattern.compile(expression)));
					break;
				default:
					throw new IllegalArgumentException("Filter type not supported with String pattern: " + filterType);
			}
		}

		return typeFilters;
	}

}
